#include <iostream>
using namespace std;

int func1() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    long long a, b, s;           // 一律long long，避免截断
    if (!(cin >> a >> b >> s)) return 0;
    int n; cin >> n;

    vector<long long> c(n+1), t(n+1, 0);
    for (int i = 1; i <= n; ++i) cin >> c[i];
    for (int i = 1; i <= n-1; ++i) cin >> t[i];

    // p[i] = 走完第i段并包含其前面的等待的总时间
    vector<long long> p(n+1, 0);
    for (int i = 1; i <= n; ++i)
        p[i] = p[i-1] + c[i] + (i >= 2 ? t[i-1] : 0);

    // f[i]：到达第i段末尾（并完成到i+1段前的等待）的最小费用
    const long long INF = (1LL<<62);
    vector<long long> f(n+1, INF);
    f[0] = 0;

    deque<int> dq;               // 维护“不超过s”那侧的候选 k（按 f[k] 单调递增）
    dq.push_back(0);

    long long best2 = INF;       // “超过s”那侧：min (f[k] - b*p[k]) over p[k] < p[i]-s
    int ptr = 0;                 // 指向还未纳入best2的最小k

    for (int i = 1; i <= n; ++i) {
        long long T = p[i] - s;

        // 扩展严格小于T的集合，更新best2（注意：best2在整个过程中累计，不重置）
        while (ptr <= i-1 && p[ptr] < T) {
            best2 = min(best2, f[ptr] - b * p[ptr]);
            ++ptr;
        }

        // 维护窗口：剔除 p[k] < T 的队头（剩下的都是 p[k] >= T，属于“不超过s”）
        while (!dq.empty() && p[dq.front()] < T) dq.pop_front();

        long long cand1 = dq.empty() ? INF : (f[dq.front()] + a);           // 不超过s
        long long cand2 = (best2 == INF) ? INF : (best2 + a + b * (p[i]-s)); // 超过s

        f[i] = min(cand1, cand2);

        // 把当前k=i加入队列，保持 f 单调
        while (!dq.empty() && f[dq.back()] >= f[i]) dq.pop_back();
        dq.push_back(i);
    }

    cout << f[n] << "\n";
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

/*
题意：给定山高 h[0..n-1]。可至多一次把任意下标 i 的高度改成任意非负整数。
要求选择一个区间 [l, r] 使得 h[l] < h[l+1] < ... < h[r]（严格递增），并输出最大长度 (r-l+1)。

核心思路：
1) 预处理两个数组：
   L[i]：以 i 结尾的最长严格递增段长度。
   R[i]：以 i 开始的最长严格递增段长度。
   不修改时的答案就是 max(L[i])。

2) 枚举“把第 i 座山改值”的情况：
   设 left_len = (i>0 ? L[i-1] : 0)   —— i 左侧能提供的最长尾段长度
      right_len = (i+1<n ? R[i+1] : 0)—— i 右侧能提供的最长首段长度
   2.1 只接一边：把 h[i] 调整到比左边最大、或比右边最小，得到候选
       left_len + 1  或  right_len + 1
   2.2 同时“桥接”两边：若存在整数 x 使 h[i-1] < x < h[i+1]，
       即 h[i+1] - h[i-1] >= 2，则可把两段拼成一个更长的段：
       left_len + 1 + right_len

3) 取所有 i 的最大值，与“不修改”的最大值比较，即答案。

复杂度：每组 O(n)。
*/

int func2() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int T;
    if (!(cin >> T)) return 0;
    while (T--) {
        int n;
        cin >> n;
        vector<long long> h(n);
        for (int i = 0; i < n; ++i) cin >> h[i];

        // 特判：n==1，改不改都是 1
        if (n == 1) {
            cout << 1 << "\n";
            continue;
        }

        // L[i]：以 i 结尾的最长严格递增段长度
        vector<int> L(n, 1), R(n, 1);
        for (int i = 1; i < n; ++i) {
            if (h[i] > h[i-1]) L[i] = L[i-1] + 1;
            else L[i] = 1;
        }
        // R[i]：以 i 开始的最长严格递增段长度
        for (int i = n-2; i >= 0; --i) {
            if (h[i] < h[i+1]) R[i] = R[i+1] + 1;
            else R[i] = 1;
        }

        // 不修改时的最大值
        int ans = 1;
        for (int i = 0; i < n; ++i) ans = max(ans, L[i]);

        // 尝试修改每个位置 i
        for (int i = 0; i < n; ++i) {
            int left_len  = (i > 0)    ? L[i-1]   : 0;
            int right_len = (i+1 < n)  ? R[i+1]   : 0;

            // 只接一边
            ans = max(ans, left_len + 1);
            ans = max(ans, right_len + 1);

            // 同时桥接两边：需要 h[i-1] < h[i] < h[i+1] 可实现
            // 因为可把 h[i] 改为任意非负整数，只要存在整数落在 (h[i-1], h[i+1)) 之间即可
            if (i > 0 && i+1 < n && h[i+1] - h[i-1] >= 2) {
                ans = max(ans, left_len + 1 + right_len);
            }
        }

        cout << ans << "\n";
    }
    return 0;
}